package com.lambert.gingko.watermark.factory;

import com.lambert.gingko.watermark.annotation.FileProcessor;
import com.lambert.gingko.watermark.config.WatermarkProperties;
import com.lambert.gingko.watermark.enums.FileType;
import com.lambert.gingko.watermark.strategy.WatermarkProcessor;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 水印策略工厂，用于管理和获取处理器
 * @author lambert
 * @since  2025/08/31
 */
@Component
public class WatermarkStrategyFactory implements InitializingBean {

    private final List<WatermarkProcessor> processors;
    private final WatermarkProperties properties;
    
    // 处理器映射表
    private final Map<FileType, WatermarkProcessor> processorMap = new HashMap<>(8);
    // 启用的处理器类型
    private Set<FileType> enabledFileTypes;

    @Autowired
    public WatermarkStrategyFactory(List<WatermarkProcessor> processors, WatermarkProperties properties) {
        this.processors = processors;
        this.properties = properties;
    }

    /**
     * 初始化处理器映射
     */
    @Override
    public void afterPropertiesSet() {
        // 初始化所有处理器映射
        for (WatermarkProcessor processor : processors) {
            FileProcessor annotation = processor.getClass().getAnnotation(FileProcessor.class);
            if (annotation != null) {
                FileType fileType = annotation.value();
                processorMap.put(fileType, processor);
            }
        }
        
        // 确定启用的处理器类型
        initializeEnabledProcessors();
    }

    /**
     * 根据文件类型获取处理器
     */
    public WatermarkProcessor getProcessor(String fileExtension) {
        FileType fileType = FileType.getByExtension(fileExtension);
        return getProcessor(fileType);
    }

    /**
     * 根据文件类型获取处理器
     */
    public WatermarkProcessor getProcessor(FileType fileType) {
        if (fileType == null) {
            return null;
        }
        
        // 检查是否启用
        if (enabledFileTypes.contains(fileType)) {
            return processorMap.get(fileType);
        }
        return null;
    }

    /**
     * 启用指定类型的处理器
     */
    public void enableProcessor(FileType type) {
        enabledFileTypes.add(type);
    }

    /**
     * 禁用指定类型的处理器
     */
    public void disableProcessor(FileType type) {
        enabledFileTypes.remove(type);
    }

    /**
     * 检查处理器是否启用
     */
    public boolean isProcessorEnabled(FileType type) {
        return enabledFileTypes.contains(type);
    }

    /**
     * 初始化启用的处理器
     */
    private void initializeEnabledProcessors() {
        List<String> enabledProcessorNames = properties.getEnabledProcessors();
        
        // 如果配置为空，默认启用所有处理器
        if (enabledProcessorNames == null || enabledProcessorNames.isEmpty()) {
            enabledFileTypes = processorMap.keySet();
            return;
        }
        
        // 根据配置初始化启用的处理器
        enabledFileTypes = enabledProcessorNames.stream()
                .map(name -> {
                    for (FileType type : FileType.values()) {
                        if (type.getTypeName().equalsIgnoreCase(name)) {
                            return type;
                        }
                    }
                    return null;
                })
                .filter(type -> type != null && processorMap.containsKey(type))
                .collect(Collectors.toSet());
    }
}
    